package com.ruoyi.campus.service.impl;

import com.ruoyi.campus.domain.MonitorDevice;
import com.ruoyi.campus.mapper.MonitorDeviceMapper;
import com.ruoyi.campus.service.IMonitorDeviceService;
import com.ruoyi.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 监控设备Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-01-17
 */
@Service
public class MonitorDeviceServiceImpl implements IMonitorDeviceService
{
    @Autowired
    private MonitorDeviceMapper monitorDeviceMapper;

    /**
     * 查询监控设备
     * 
     * @param deviceId 监控设备主键
     * @return 监控设备
     */
    @Override
    public MonitorDevice selectMonitorDeviceByDeviceId(Long deviceId)
    {
        return monitorDeviceMapper.selectById(deviceId);
    }

    /**
     * 查询监控设备列表
     * 
     * @param monitorDevice 监控设备
     * @return 监控设备
     */
    @Override
    public List<MonitorDevice> selectMonitorDeviceList(MonitorDevice monitorDevice)
    {
        return monitorDeviceMapper.selectMonitorDeviceList(monitorDevice);
    }

    /**
     * 查询监控设备详情（包含关联信息）
     * 
     * @param deviceId 设备ID
     * @return 监控设备
     */
    @Override
    public MonitorDevice selectMonitorDeviceDetail(Long deviceId)
    {
        return monitorDeviceMapper.selectMonitorDeviceDetail(deviceId);
    }

    /**
     * 根据设备编码查询设备
     * 
     * @param deviceCode 设备编码
     * @return 监控设备
     */
    @Override
    public MonitorDevice selectMonitorDeviceByCode(String deviceCode)
    {
        return monitorDeviceMapper.selectMonitorDeviceByCode(deviceCode);
    }

    /**
     * 查询学校的监控设备
     * 
     * @param schoolId 学校ID
     * @param deviceType 设备类型（可选）
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectDevicesBySchool(Long schoolId, Integer deviceType)
    {
        return monitorDeviceMapper.selectDevicesBySchool(schoolId, deviceType);
    }

    /**
     * 查询在线设备列表
     * 
     * @param schoolId 学校ID（可选）
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectOnlineDevices(Long schoolId)
    {
        return monitorDeviceMapper.selectOnlineDevices(schoolId);
    }

    /**
     * 查询离线设备列表
     * 
     * @param schoolId 学校ID（可选）
     * @param offlineMinutes 离线时间阈值（分钟）
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectOfflineDevices(Long schoolId, Integer offlineMinutes)
    {
        return monitorDeviceMapper.selectOfflineDevices(schoolId, offlineMinutes);
    }

    /**
     * 查询故障设备列表
     * 
     * @param schoolId 学校ID（可选）
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectFaultDevices(Long schoolId)
    {
        return monitorDeviceMapper.selectFaultDevices(schoolId);
    }

    /**
     * 查询需要维护的设备列表
     * 
     * @param schoolId 学校ID（可选）
     * @param days 维护周期天数
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectMaintenanceDevices(Long schoolId, Integer days)
    {
        return monitorDeviceMapper.selectMaintenanceDevices(schoolId, days);
    }

    /**
     * 根据地理位置查询附近设备
     * 
     * @param latitude 纬度
     * @param longitude 经度
     * @param distance 距离（千米）
     * @param deviceType 设备类型（可选）
     * @return 监控设备集合
     */
    @Override
    public List<MonitorDevice> selectDevicesByLocation(Double latitude, Double longitude, Double distance, Integer deviceType)
    {
        return monitorDeviceMapper.selectDevicesByLocation(latitude, longitude, distance, deviceType);
    }

    /**
     * 查询设备状态统计
     * 
     * @param schoolId 学校ID（可选）
     * @return 统计信息
     */
    @Override
    public Map<String, Object> selectDeviceStatusStatistics(Long schoolId)
    {
        return monitorDeviceMapper.selectDeviceStatusStatistics(schoolId);
    }

    /**
     * 查询设备类型统计
     * 
     * @param schoolId 学校ID（可选）
     * @return 统计信息集合
     */
    @Override
    public List<Map<String, Object>> selectDeviceTypeStatistics(Long schoolId)
    {
        return monitorDeviceMapper.selectDeviceTypeStatistics(schoolId);
    }

    /**
     * 查询设备心跳状态
     * 
     * @param schoolId 学校ID（可选）
     * @return 心跳状态集合
     */
    @Override
    public List<Map<String, Object>> selectDeviceHeartbeatStatus(Long schoolId)
    {
        return monitorDeviceMapper.selectDeviceHeartbeatStatus(schoolId);
    }

    /**
     * 新增监控设备
     * 
     * @param monitorDevice 监控设备
     * @return 结果
     */
    @Override
    public int insertMonitorDevice(MonitorDevice monitorDevice)
    {
        monitorDevice.setCreateTime(DateUtils.getNowDate());
        return monitorDeviceMapper.insert(monitorDevice);
    }

    /**
     * 修改监控设备
     * 
     * @param monitorDevice 监控设备
     * @return 结果
     */
    @Override
    public int updateMonitorDevice(MonitorDevice monitorDevice)
    {
        monitorDevice.setUpdateTime(DateUtils.getNowDate());
        return monitorDeviceMapper.updateById(monitorDevice);
    }

    /**
     * 批量删除监控设备
     * 
     * @param deviceIds 需要删除的监控设备主键
     * @return 结果
     */
    @Override
    public int deleteMonitorDeviceByDeviceIds(Long[] deviceIds)
    {
        int result = 0;
        for (Long deviceId : deviceIds) {
            result += monitorDeviceMapper.deleteById(deviceId);
        }
        return result;
    }

    /**
     * 删除监控设备信息
     * 
     * @param deviceId 监控设备主键
     * @return 结果
     */
    @Override
    public int deleteMonitorDeviceByDeviceId(Long deviceId)
    {
        return monitorDeviceMapper.deleteById(deviceId);
    }

    /**
     * 更新设备心跳时间
     * 
     * @param deviceId 设备ID
     * @return 结果
     */
    @Override
    public int updateDeviceHeartbeat(Long deviceId)
    {
        MonitorDevice device = selectMonitorDeviceByDeviceId(deviceId);
        if (device != null) {
            return monitorDeviceMapper.updateDeviceHeartbeat(device.getDeviceCode(), new Date());
        }
        return 0;
    }

    /**
     * 批量更新设备状态
     * 
     * @param deviceIds 设备ID列表
     * @param status 状态
     * @return 结果
     */
    @Override
    public int updateDeviceStatusBatch(Long[] deviceIds, Integer status)
    {
        List<Long> deviceIdList = java.util.Arrays.asList(deviceIds);
        return monitorDeviceMapper.updateDeviceStatusBatch(deviceIdList, status);
    }

    /**
     * 批量更新设备在线状态
     * 
     * @param deviceCodes 设备编码列表
     * @param onlineStatus 在线状态
     * @return 结果
     */
    @Override
    public int updateDeviceOnlineStatusBatch(String[] deviceCodes, Integer onlineStatus)
    {
        List<String> deviceCodeList = java.util.Arrays.asList(deviceCodes);
        return monitorDeviceMapper.updateDeviceOnlineStatusBatch(deviceCodeList, onlineStatus);
    }

    /**
     * 检测并更新离线设备
     * 
     * @param timeoutMinutes 超时时间（分钟）
     * @return 结果
     */
    @Override
    public int updateOfflineDevices(Integer timeoutMinutes)
    {
        return monitorDeviceMapper.updateOfflineDevices(timeoutMinutes * 60); // 转换为秒
    }

    /**
     * 校验设备编码是否唯一
     * 
     * @param monitorDevice 设备信息
     * @return 结果
     */
    @Override
    public boolean checkDeviceCodeUnique(MonitorDevice monitorDevice)
    {
        Long deviceId = (monitorDevice.getDeviceId() == null) ? -1L : monitorDevice.getDeviceId();
        int count = monitorDeviceMapper.checkDeviceCodeUnique(monitorDevice.getDeviceCode(), deviceId);
        return count == 0;
    }

    /**
     * 校验IP端口是否唯一
     * 
     * @param monitorDevice 设备信息
     * @return 结果
     */
    @Override
    public boolean checkIpPortUnique(MonitorDevice monitorDevice)
    {
        Long deviceId = (monitorDevice.getDeviceId() == null) ? -1L : monitorDevice.getDeviceId();
        // TODO: 需要根据实际MonitorDevice类结构调整IP和端口字段获取方式
        // int count = monitorDeviceMapper.checkIpPortUnique(monitorDevice.getIpAddress(), monitorDevice.getPort(), deviceId);
        return true; // 临时返回true，表示IP端口唯一
    }
} 